package com.ssm.controller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.ssm.pojo.Build;
import com.ssm.pojo.Task;
import com.ssm.service.TaskService;
import com.ssm.util.PageUtil;
import com.ssm.vo.BuildVo;
import com.ssm.vo.TaskVo;
import org.omg.PortableInterceptor.INACTIVE;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Controller
public class TaskController {
    @Autowired
    private TaskService taskService;
    //主页显示所有的任务
    //使用restfu风格的传/接参数的方法
    @RequestMapping(value = "tasks/{pageNum}",method = RequestMethod.GET)
    public String tasks(Map<String,Object> map, @PathVariable("pageNum") Integer pageNum, HttpServletRequest request){
        //开始的页码，每页显示的数量
        PageHelper.startPage(pageNum,2);
        //查询所有的任务，并在主页显示，但是已经被接收的不会显示
        //只查询没有被接收的任务，在sql语句中指定state为0，即未接收状态
        List<Task> tasks = taskService.selectTasks();

        //查询任务表，多表联合查询，实现用户和任务的信息展示
        PageInfo<Task> pageInfo = new PageInfo<>(tasks,5);
        String page = PageUtil.getPageInfo(pageInfo, request);
        //把任务信息和页码数据传到前端页面进行显示
        map.put("tasks",tasks);
        map.put("page",page);
        return "resources/page/main1";
    }

    @RequestMapping(value = "addTask",method = RequestMethod.POST)
    public String addTask(Integer stuId,String taskName,String reward,String taskcontext){
        //添加新任务后，遍历数据库，进而进行分页显示
        System.out.println(stuId);
        int i = taskService.addTask(stuId,taskName,reward,taskcontext);
        return "redirect:/tasks/1";
    }

    //通过货品的id来获取发布人发布的任务信息，并显示
    //待解决按钮的请求处理
    @RequestMapping(value = "acceptTask/{taskId}",method = RequestMethod.GET)
    public String acceptTask(@PathVariable("taskId") Integer taskId,Map<String,Object> map){
        //获取请求信息，最后把信息遍历在确认请求页面
        List<Task> list = taskService.selectTaskByTaskId(taskId);
        map.put("list",list);
        map.put("taskId",taskId);
        System.out.println(list);
        return "resources/page/util/SureTask";
    }

//    @RequestMapping(value = "acceptSure",method = RequestMethod.POST)
//    public String acceptSure(Integer state ,Integer taskId,Integer acceptStuId,Map<String,Object> map){
//        //当点击确认接收后，更新任务列表，设置任务状态为已接收，设置接收者Id，即登陆用户的id，设置被接受的任务id，为了查询
//        Integer s = taskService.updateState(state,acceptStuId,taskId);
//        if(s>=1){
//            System.out.println("任务状态改变成功");
////            //跳转查询，发布者，任务，接收者的信息，并在已接受页面进行显示
////            List<Task> t = taskService.selectThree(taskId);
////            List<Task> t1 = taskService.selectThree1(taskId);
////            map.put("t",t);
////            map.put("t1",t1);
//            //return "resources/page/util/acceptTasksPast";
////            return "redirect:/acceptTask1/1";
//        }
//        return "";
//    }
    //sureTask发来请求
    //确认任务信息，通过隐藏域，把state=1，即接收状态，学生的id和任务的id
    @RequestMapping(value = "acceptSure/{pagenum}",method =  RequestMethod.GET)
    public String acceptSure(@PathVariable("pagenum")Integer pagenum,HttpServletRequest request,Map<String,Object> map,Integer state,Integer taskId,Integer acceptStuId){
        //当点击确认接收后，就把选中的任务(根据taskId确认)，的状态和接收者的id，在数据库中更改
        Integer s = taskService.updateState(state,acceptStuId,taskId);
        //然后在查询时，把state设置为1，即已经被接收，根据已经被接受来查看所有的已经被接收的任务，在页面显示
         PageHelper.startPage(pagenum,2);
         //List<Task> t = taskService.selectThree();
         List<Task> t1 = taskService.selectThree1();
         //PageInfo<Task> pageInfo = new PageInfo<>(t,5);
         PageInfo<Task> pageInfo1 = new PageInfo<>(t1,5);
         String page = PageUtil.getPageInfoAccept(pageInfo1, request);
         //map.put("t",t);
         map.put("t1",t1);
         map.put("page",page);
         return "resources/page/util/acceptTasksPast";
    }

    //查询自己发布的任务
    @RequestMapping(value = "selectSelf/{page}",method = RequestMethod.GET)
    public String selectSelf(@PathVariable("page") Integer page, HttpSession session,HttpServletRequest request,Map<String,Object> map){
        //得到登陆用户的id，然后进行连表查询，查询结果是登陆用户已经发布的任务
        Integer stuId = (Integer) session.getAttribute("stuId");
        PageHelper.startPage(page,2);
        //查询登陆用户的任务，在我发布的任务显示
        List<Task> task = taskService.selectSelf(stuId);
        //查询任务表，多表联合查询，实现用户和任务的信息展示
        PageInfo<Task> pageInfo2 = new PageInfo<>(task,5);
        String p = PageUtil.getPageInfoSelf(pageInfo2, request);
        map.put("tasks",task);
        map.put("page",p);
        return "resources/page/util/releaseTasksPast";
    }
    //releaseTasksPast，取消按钮，发送请求
    @RequestMapping(value = "cancelTask/{taskId}",method = RequestMethod.GET)
    public String deleteTask(@PathVariable("taskId") Integer taskId){
        System.out.println("进入到删除任务界面");
        //该用户点击取消，该任务删除,根据该登陆用户的id删除任务
        Integer i = taskService.deleteTask(taskId);
        if(i>=1){
            return "redirect:/selectSelf/1";
        }
        return "";
    }


    //确认收货
    //从acceptTasksPast页面按钮传过来的值
    @RequestMapping(value = "receiveTask/{taskId}/{stuId}",method = RequestMethod.GET)
    public String receiveTask(@PathVariable("taskId") Integer taskId,@PathVariable("stuId")Integer stuId,Map<String,Object> map){
        //对于接收正在解决的任务，登陆者登陆后，如果有自己发布的任务，并且自己的任务已经被完成，
        //这时候可以点击确认完成任务，根据传过来的任务taskId,update数据库中的任务状态
        Integer i = taskService.updateReceiveState(taskId);
        //如果任务的状态更改成功，显示更改成功，返回，点击已经完成的任务查看完成的任务
        if(i>=1){
//            List<Task> list = taskService.selectTaskByState(stuId);
//            map.put("list",list);
            return "resources/page/util/finishPage";
        }else {
            return "resources/page/util/fail";
        }

    }


    @RequestMapping(value = "deleteTask/{taskId}",method = RequestMethod.GET)
    public String delTask(@PathVariable("taskId") Integer taskId){
        //该用户点击取消，该任务删除,根据该登陆用户的id删除任务
        //复用上面的根据taskId删除任务的方法
        //当任务完成后，完成的任务是根据登陆人的stuId查找的，所以完成任务里面显示的是谁登录的且已经完成的任务
        //因为传过来的taskId是遍历出来的每个完成用户的id，所以根据此id就可以删除已经完成的任务
        Integer i = taskService.deleteTask(taskId);
        if(i>=1){
            //删除成功后，重新遍历任务列表，查找其他完成的任务，(可能不会删除完，所以一个一个删除)
            return "redirect:/selectFinishTask/1";
        }else {
            return "resources/page/util/fail";
        }
    }

    @RequestMapping(value = "selectFinishTask/{pageNum}",method = RequestMethod.GET)
    public String selectFinshTask(@PathVariable("pageNum")Integer pageNum,HttpSession session,HttpServletRequest request,Map<String,Object> map){
        System.out.println(pageNum);
        PageHelper.startPage(pageNum,2);
        //查询登陆用户的任务，在我发布的任务显示
        Integer stuId = (Integer) session.getAttribute("stuId");
        //通过发布者的id，查询所有发布者发布的任务，任务状态是2，即已经完成
        List<Task> task = taskService.selectFinishTask(stuId);
        //查询任务表，多表联合查询，实现用户和任务的信息展示
        PageInfo<Task> pageInfo2 = new PageInfo<>(task,5);
        String p = PageUtil.getPageInfoFinish(pageInfo2, request);
        map.put("tasks",task);
        map.put("page",p);
        return "resources/page/util/finish";
    }


    //查询后台的任务信息
    @RequestMapping("/selTasks")
    @ResponseBody
    public TaskVo selTasks(int page, int limit){
        System.out.println("进入查询");
        TaskVo taskVo = new TaskVo();
        taskVo.setCode(0);
        taskVo.setMsg("");
        List<Task> tasks = taskService.selTasks();
        //截取当前页面需要显示的数据
        //计算出当前页数据开始的索引
        int start = (page - 1) * limit;//开始的索引
        int end = page*limit;//结束的索引
        //获取到可以subList的最大索引
        int count = tasks.size();
        List<Task> data;
        if(end>count){
            if(count==end-limit){
                data = tasks.subList(start-limit,count);
            }else {
                data = tasks.subList(start,count);
            }
        }else{
            data = tasks.subList(start,end);
        }
        taskVo.setCount(count);
        taskVo.setData(data);
        return taskVo;
    }

    //删除后台任务信息
    //删除任务
    @RequestMapping("/delTaskById")
    @ResponseBody
    public String delTaskById(int taskId){
        int i = taskService.delTaskById(taskId);
        if(i>=1){
            return "DELETE SUCCESS";
        }else {
            return "DELETE FAIL";
        }

    }



    //批量删除所选的任务
    @RequestMapping(value = "/delTasks",method = RequestMethod.POST)
    @ResponseBody
    public String deleteBuilds(int[] ids){

//        String res = "(";
//        for (int i = 0; i < ids.length; i++) {
//            if(i==ids.length-1){
//                res += ids[i]+")";
//            }else {
//                res += ids[i]+",";
//            }
//        }
//        System.out.println(res);
        if (ids!=null){
            int i = taskService.delTasks(ids);
            System.out.println(i);
            if(i>=1){
                return "BATCHDELETE SUCCESS";
            }else {
                return "DELETE FAIl";
            }
        }
        return "Please Select";

    }


    //查询操作
    @RequestMapping("/selectTasks")
    @ResponseBody
    public TaskVo getUserTypes(Integer state,int page, int limit){
        TaskVo taskVo = new TaskVo();
        List<Task> tasks = null;
        try {
            if(state==null){
                //如果任务的状态不等于空的时候，可以查询所有
                tasks = taskService.selTaskss();
            }else{
                tasks = taskService.selTask(state);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            taskVo.setCode(0);
            taskVo.setMsg("");
            //截取当前页面需要显示的数据
            //计算出当前页数据开始的索引
            int start = (page - 1) * limit;//开始的索引
            int end = page*limit;//结束的索引
            //获取到可以subList的最大索引
            int count = tasks.size();
            List<Task> data;
            if(end>count){
                if(count==end-limit){
                    data = tasks.subList(start-limit,count);
                }else {
                    data = tasks.subList(start,count);
                }
            }else{
                data = tasks.subList(start,end);
            }
            taskVo.setCount(count);
            taskVo.setData(data);
        }
        return taskVo;
    }

    @RequestMapping(value = "chaxun/{pageNum}",method = RequestMethod.GET)
    public String chaxun(@PathVariable("pageNum")Integer pageNum,HttpServletRequest request,String key,Map<String,Object> map){
        List<Task> tasks = null;
        PageHelper.startPage(pageNum,2);
        //查询所有的任务，并在主页显示，但是已经被接收的不会显示
        //只查询没有被接收的任务，在sql中固定
        if(key==null){
            tasks = taskService.selectTasks();
        }else {
            tasks = taskService.selectByKey(key);
        }
        //查询任务表，多表联合查询，实现用户和任务的信息展示
        PageInfo<Task> pageInfo = new PageInfo<>(tasks,5);
        String page = PageUtil.getPageInfoCha(pageInfo, request);
        map.put("tasks",tasks);
        map.put("page",page);
        return "resources/page/main1";
    }
}
